package thread;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.support.annotation.Nullable;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 创建时间：2018年03月09日14:13 <br>
 * 作者：fuchaoyang <br>
 * 描述：
 * 核心线程数5，最大10，空闲时间200ms，阻塞队列为5
 * 创建20个task。
 * 那么前5个，会被核心线程执行；
 * 6-10被加到缓冲队列中；
 * 11-15 会直接开新线程；
 * 16-20 没有空闲线程，就会执行拒绝 RejectedExecutionHandler（默认抛异常）
 * 1分钟后创建的5个task，线程池有空闲线程，将会被执行
 */

public class TestThreadPoolUI extends Activity {

  private ThreadPoolExecutor mExecutor;
  private int index;

  @Override protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    // 当线程池中的线程数量大于 corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止。这样，线程池可以动态的调整池中的线程数。
    mExecutor = new ThreadPoolExecutor(5, 10, 200, TimeUnit.MILLISECONDS,
      new LinkedBlockingQueue<Runnable>(5), new ThreadPoolExecutor.DiscardPolicy());

    // java不推荐手动创建线程池，而通过Executors提供的静态方法创建（3种）
    //mExecutor = Executors.newFixedThreadPool() // LinkedBlockingQueue Integer.MAX_VALUE
    //new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());

    //Executors.newCachedThreadPool()
    // ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>())

    for (int i = 0; i < 20; i++) {
      runTask();
    }

    // 等待1s后再执行5个任务，前面的任务已经执行完成了，这5个任务会被执行
    new Handler().postDelayed(new Runnable() {
      @Override public void run() {
        for (int i = 0; i < 5; i++) {
          runTask();
        }
        shutDown();
        // shutDown之后不再接收task
        for (int i = 0; i < 5; i++) {
          runTask();
        }
      }
    }, 1000);
  }

  private void runTask() {
    index++;
    MyTask myTask = new MyTask(index);
    mExecutor.execute(myTask);
    System.out.println("线程池中线程数目："
      + mExecutor.getPoolSize()
      + "，队列中等待执行的任务数目："
      + mExecutor.getQueue().size()
      + "，已执行完毕的任务数目："
      + mExecutor.getCompletedTaskCount());
  }

  private void shutDown() {
    // 不再接收task，但是会把当前缓存队列中的task执行完成
    mExecutor.shutdown();
    // 不再接收task，丢弃当前缓存队列中的task
    //executor.shutdownNow();
  }

  class MyTask implements Runnable {
    private int taskNum;

    public MyTask(int num) {
      this.taskNum = num;
    }

    @Override public void run() {
      System.out.println("正在执行task " + taskNum);
      try {
        Thread.sleep(40/*00*/);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
      System.out.println("task " + taskNum + "执行完毕");
    }
  }
}
